package com.pirestupppai.ui.activity;

import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v4.content.ContextCompat;
import android.view.View;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;

import com.orhanobut.logger.Logger;
import com.pirestupppai.R;
import com.pirestupppai.base.BaseActivity;
import com.pirestupppai.base.BaseApplication;
import com.pirestupppai.bean.LoginUser;
import com.pirestupppai.bean.RongIMItem;
import com.pirestupppai.bean.TupaiUser;
import com.pirestupppai.common.Constant;
import com.pirestupppai.common.Urls;
import com.pirestupppai.network.NetworkRequest;
import com.pirestupppai.network.TupaiSubscriber;
import com.pirestupppai.ui.fragment.FeedFragment;
import com.pirestupppai.ui.fragment.HomeFragment;
import com.pirestupppai.ui.fragment.IMFragment;
import com.pirestupppai.ui.fragment.ProfileFragment;
import com.pirestupppai.utils.Utils;
import com.pirestupppai.utils.WeakReferenceHandler;
import com.pirestupppai.widgets.dialog.ReleaseImageOrVideoDialog;
import com.pirestupppai.widgets.dialog.ReleasePopupwindow;

import java.util.HashMap;
import java.util.Map;

import butterknife.BindView;
import io.rong.imkit.RongIM;
import io.rong.imkit.model.UIConversation;
import io.rong.imlib.RongIMClient;
import io.rong.imlib.model.Conversation;
import io.rong.imlib.model.Message;
import io.rong.imlib.model.UserInfo;

import static io.rong.imkit.utils.SystemUtils.getCurProcessName;


public class MainActivity extends BaseActivity {

    @BindView(R.id.tab_home_layout)
    RelativeLayout homeTab;
    @BindView(R.id.tab_feed_layout)
    RelativeLayout feedTab;
    @BindView(R.id.tab_message_layout)
    RelativeLayout messageTab;
    @BindView(R.id.tab_profile_layout)
    RelativeLayout profileTab;
    @BindView(R.id.tab_release_layout)
    ImageView releaseTab;
    @BindView(R.id.tab_home_iv)
    ImageView homeIv;
    @BindView(R.id.tab_feed_iv)
    ImageView feedIv;
    @BindView(R.id.tab_message_iv)
    ImageView messageIv;
    @BindView(R.id.tab_profile_iv)
    ImageView profileIv;
    @BindView(R.id.tab_message_dot)
    ImageView messageDotIv;
    @BindView(R.id.bottom_bar_layout)
    LinearLayout bottomBar;

    private static final int MSG_RECEIVE = 110;
    private static final int MSG_GET_UER = 120;
    private final int DEFAULT_FRAGMENT_ID = -1;
    private int mCurrentFragmentId = DEFAULT_FRAGMENT_ID;
    private String mSenderUid = "";
    private Map<String, RongIMItem> mUserList = new HashMap<>();

    private FragmentManager mFragmentManager;
    private HomeFragment mHomeFragment;
    private FeedFragment mFeedFragment;
    private IMFragment mIMFragment;
    private ProfileFragment mProfileFragment;
    private ReleasePopupwindow mRelesePopupwindow;
    private WeakReferenceHandler mHandler = new WeakReferenceHandler(this);

    // 是否准备双击退出程序
    private long mFirstTime = 0;
    private static final int EXIT_TIME = 2 * 1000;

    @Override
    protected Context getActivityContext() {
        return this;
    }

    @Override
    protected int loadParentLayout() {
        return R.layout.activity_main;
    }

    @Override
    protected void initViews() {
        mFragmentManager = getSupportFragmentManager();
        showFragment(R.id.tab_home_layout);

        if (Urls.BASE_URL.equals(Urls.RELEASE_URL)) {
            bottomBar.setBackgroundColor(getResources().getColor(R.color.white));
        } else {
            bottomBar.setBackgroundColor(getResources().getColor(R.color.colorAccent));
        }
    }

    @Override
    protected void initListeners() {
        homeTab.setOnClickListener(this);
        feedTab.setOnClickListener(this);
        messageTab.setOnClickListener(this);
        profileTab.setOnClickListener(this);
        releaseTab.setOnClickListener(this);
    }

    @Override
    protected void initLogic() {
        getIMtoken();
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.tab_home_layout:
                showFragment(R.id.tab_home_layout);
                break;
            case R.id.tab_feed_layout:
                showFragment(R.id.tab_feed_layout);
                break;
            case R.id.tab_message_layout:
                messageDotIv.setVisibility(View.GONE);
                showFragment(R.id.tab_message_layout);
//                startActivity(new Intent(mContext, MessageListActivity.class));
                break;
            case R.id.tab_profile_layout:
                showFragment(R.id.tab_profile_layout);
                break;
            case R.id.tab_release_layout:
//                showReleasePopupWindow(v);
                ReleaseImageOrVideoDialog releaseImageOrVideoDialog = new ReleaseImageOrVideoDialog(mContext);
                releaseImageOrVideoDialog.show();
                break;
        }
    }

    /**
     * 回退键重写
     */
    @Override
    public void onBackPressed() {
        exitApp();
    }


    @Override
    public boolean handleMessage(android.os.Message msg) {
        switch (msg.what) {
            case MSG_RECEIVE:
                //显示小红点
                messageDotIv.setVisibility(View.VISIBLE);
                break;
            case MSG_GET_UER:
                //获取融云聊天的用户数据
                NetworkRequest.getInstance().getUserData(Integer.parseInt(mSenderUid), mContext,
                        new TupaiSubscriber<TupaiUser>(mContext) {
                            @Override
                            protected void requestSuccess(TupaiUser tupaiUser) {
                                final String nickname = tupaiUser.getNickname();
                                final Uri avatar = Uri.parse(tupaiUser.getAvatar() + "?imageView2/2/w/200/h/200");
                                mUserList.put(mSenderUid, new RongIMItem(mSenderUid, nickname, avatar));
                                RongIM.setUserInfoProvider(new RongIM.UserInfoProvider() {
                                    @Override
                                    public UserInfo getUserInfo(String s) {
                                        return new UserInfo(mSenderUid, nickname, avatar);
                                    }
                                }, true);
                                RongIM.getInstance().refreshUserInfoCache(new UserInfo(mSenderUid, nickname, avatar));
                            }

                            @Override
                            protected void requestError(String error) {
                                Logger.d(error);
                            }
                        });
                break;
        }
        return true;
    }

    /**
     * 点击后退键两次退出app
     */
    private void exitApp() {
        long secondTime = System.currentTimeMillis();
        if (secondTime - mFirstTime > EXIT_TIME) {
            Utils.showBar(mContext, "再按一次退出程序");
            mFirstTime = secondTime;
        } else {
            finish();
            System.exit(0);
        }
    }

    /**
     * 弹出发布弹窗
     */
    private void showReleasePopupWindow(View view) {
        if (null == mRelesePopupwindow) {
            mRelesePopupwindow = new ReleasePopupwindow(this);
        }
        mRelesePopupwindow.showCameraPopupwindow(view);
    }

    /**
     * 显示fragemnt
     */
    private void showFragment(int id) {
        if (mCurrentFragmentId == id) {
            return;
        }

        Fragment currentFragment = getFragment(mCurrentFragmentId);
        FragmentTransaction transaction = mFragmentManager.beginTransaction();
        if (currentFragment != null) {
            transaction.hide(currentFragment);
        }

        Fragment toFragment = getFragment(id);

        if (toFragment.isAdded()) {
            transaction.show(toFragment).commit();
        } else {
            transaction.add(R.id.main_content_layout, toFragment).commit();
        }
        showTabImage(id);
        mCurrentFragmentId = id;
    }

    public Fragment getFragment(int id) {
        switch (id) {
            case R.id.tab_home_layout:
                if (mHomeFragment == null) {
                    mHomeFragment = new HomeFragment();
                }
                return mHomeFragment;
            case R.id.tab_feed_layout:
                if (mFeedFragment == null) {
                    mFeedFragment = new FeedFragment();
                }
                return mFeedFragment;
            case R.id.tab_message_layout:
                if (mIMFragment == null) {
                    mIMFragment = new IMFragment();
                }
                return mIMFragment;
            case R.id.tab_profile_layout:
                if (mProfileFragment == null) {
                    mProfileFragment = new ProfileFragment();
                }
                return mProfileFragment;


        }
        return mHomeFragment;
    }

    /**
     * 底部栏显示当前页
     */
    private void showTabImage(int id) {
        resetIv();
        switch (id) {
            case R.id.tab_home_layout:
                homeIv.setImageDrawable(ContextCompat.getDrawable(mContext, R.drawable.tab_home_sel));
                break;
            case R.id.tab_feed_layout:
                feedIv.setImageDrawable(ContextCompat.getDrawable(mContext, R.drawable.tab_feed_sel));
                break;
            case R.id.tab_message_layout:
                messageIv.setImageDrawable(ContextCompat.getDrawable(mContext, R.drawable.tab_message_sel));
                break;
            case R.id.tab_profile_layout:
                profileIv.setImageDrawable(ContextCompat.getDrawable(mContext, R.drawable.tab_profile_sel));
                break;
        }
    }

    /**
     * 重置为未选择视图
     */
    private void resetIv() {
        homeIv.setImageDrawable(ContextCompat.getDrawable(mContext, R.drawable.tab_home_nor));
        feedIv.setImageDrawable(ContextCompat.getDrawable(mContext, R.drawable.tab_feed_nor));
        messageIv.setImageDrawable(ContextCompat.getDrawable(mContext, R.drawable.tab_message_nor));
        profileIv.setImageDrawable(ContextCompat.getDrawable(mContext, R.drawable.tab_profile_nor));
    }


    // --------------------------- 融云相关 --------------------------------------------

    /**
     * 获取融云token
     */
    private void getIMtoken() {
        NetworkRequest.getInstance().getIMtoken(this,
                new TupaiSubscriber<String>(mContext) {
                    @Override
                    protected void requestSuccess(String s) {
                        LoginUser.getInstance().setImToken(s);
                        connectIM(s);
                    }

                    @Override
                    protected void requestError(String error) {

                    }
                });
    }

    /**
     * <p>连接服务器，在整个应用程序全局，只需要调用一次，需在 {init(Context)} 之后调用。</p>
     * <p>如果调用此接口遇到连接失败，SDK 会自动启动重连机制进行最多10次重连，分别是1, 2, 4, 8, 16, 32, 64, 128, 256, 512秒后。
     * 在这之后如果仍没有连接成功，还会在当检测到设备网络状态变化时再次进行重连。</p>
     *
     * @param token 从服务端获取的用户身份令牌（Token）。
     * @return RongIM  客户端核心类的实例。
     */
    private void connectIM(final String token) {
        if (mContext.getApplicationInfo().packageName.equals(getCurProcessName(BaseApplication.getAppContext()))) {

            RongIM.connect(token, new RongIMClient.ConnectCallback() {

                /**
                 * Token 错误。可以从下面两点检查 1.  Token 是否过期，如果过期您需要向 App Server 重新请求一个新的 Token
                 * 2.  token 对应的 appKey 和工程里设置的 appKey 是否一致
                 */
                @Override
                public void onTokenIncorrect() {
                    Logger.d("onTokenIncorrect:" + token);
                }

                /**
                 * 连接融云成功
                 *
                 * @param userid 当前 token 对应的用户 id
                 */
                @Override
                public void onSuccess(String userid) {
                    Logger.d("融云userid:" + userid);
                    initIMData();
                }

                /**
                 * 连接融云失败
                 *
                 * @param errorCode 错误码，可到官网 查看错误码对应的注释
                 */
                @Override
                public void onError(RongIMClient.ErrorCode errorCode) {
                    Logger.d("onError : " + errorCode);
                }
            });
        }
    }

    /**
     * 初始化融云数据和消息监听
     */
    private void initIMData() {
        final String id = Integer.toString(LoginUser.getInstance().getId());
        final String nickname = LoginUser.getInstance().getNickname();
        final Uri avatar = Uri.parse(LoginUser.getInstance().getAvatar() + "?imageView2/2/w/200/h/200");
        RongIM.setUserInfoProvider(new RongIM.UserInfoProvider() {
            @Override
            public UserInfo getUserInfo(String s) {
                return new UserInfo(id, nickname, avatar);
            }
        }, true);
        RongIM.getInstance().refreshUserInfoCache(new UserInfo(id, nickname, avatar));


        // 会话列表监听
        RongIM.setConversationListBehaviorListener(new RongIM.ConversationListBehaviorListener() {
            /**
             * 当点击会话头像后执行。
             *
             * @param context          上下文。
             * @param conversationType 会话类型。
             * @param targetId         被点击的用户id。
             * @return 如果用户自己处理了点击后的逻辑处理，则返回 true，否则返回 false，false 走融云默认处理方式。
             */
            @Override
            public boolean onConversationPortraitClick(Context context, Conversation.ConversationType conversationType, String targetId) {
                Intent intent = new Intent(mContext, UserActivity.class);
                intent.putExtra(Constant.IntentKey.UID, Integer.parseInt(targetId));
                mContext.startActivity(intent);
                return true;
            }

            /**
             * 当长按会话头像后执行。
             *
             * @param context          上下文。
             * @param conversationType 会话类型。
             * @param targetId         被点击的用户id。
             * @return 如果用户自己处理了点击后的逻辑处理，则返回 true，否则返回 false，false 走融云默认处理方式。
             */
            @Override
            public boolean onConversationPortraitLongClick(Context context, Conversation.ConversationType conversationType, String targetId) {
                return false;
            }

            /**
             * 长按会话列表中的 item 时执行。
             *
             * @param context        上下文。
             * @param view           触发点击的 View。
             * @param uiConversation 长按时的会话条目。
             * @return 如果用户自己处理了长按会话后的逻辑处理，则返回 true， 否则返回 false，false 走融云默认处理方式。
             */
            @Override
            public boolean onConversationLongClick(Context context, View view, UIConversation uiConversation) {
                return false;
            }

            /**
             * 点击会话列表中的 item 时执行。
             *
             * @param context        上下文。
             * @param view           触发点击的 View。
             * @param uiConversation 会话条目。
             * @return 如果用户自己处理了点击会话后的逻辑处理，则返回 true， 否则返回 false，false 走融云默认处理方式。
             */
            @Override
            public boolean onConversationClick(Context context, View view, UIConversation uiConversation) {
                return false;
            }
        });

        // 会话界面监听
        RongIM.setConversationBehaviorListener(new RongIM.ConversationBehaviorListener() {
            /**
             * 当点击用户头像后执行。
             *
             * @param context          上下文。
             * @param conversationType 会话类型。
             * @param userInfo         被点击的用户的信息。
             * @return 如果用户自己处理了点击后的逻辑，则返回 true，否则返回 false，false 走融云默认处理方式。
             */
            @Override
            public boolean onUserPortraitClick(Context context, Conversation.ConversationType conversationType, UserInfo userInfo) {
                Intent intent = new Intent(mContext, UserActivity.class);
                intent.putExtra(Constant.IntentKey.UID, Integer.parseInt(userInfo.getUserId()));
                mContext.startActivity(intent);
                return true;
            }

            /**
             * 当长按用户头像后执行。
             *
             * @param context          上下文。
             * @param conversationType 会话类型。
             * @param userInfo         被点击的用户的信息。
             * @return 如果用户自己处理了点击后的逻辑，则返回 true，否则返回 false，false 走融云默认处理方式。
             */
            @Override
            public boolean onUserPortraitLongClick(Context context, Conversation.ConversationType conversationType, UserInfo userInfo) {
                return false;
            }

            /**
             * 当长按消息时执行。
             *
             * @param context 上下文。
             * @param view    触发点击的 View。
             * @param message 被长按的消息的实体信息。
             * @return 如果用户自己处理了长按后的逻辑，则返回 true，否则返回 false，false 走融云默认处理方式。
             */
            @Override
            public boolean onMessageClick(Context context, View view, Message message) {
                return false;
            }

            /**
             * 当点击链接消息时执行。
             *
             * @param context 上下文。
             * @param link    被点击的链接。
             * @return 如果用户自己处理了点击后的逻辑处理，则返回 true， 否则返回 false, false 走融云默认处理方式。
             */
            @Override
            public boolean onMessageLinkClick(Context context, String link) {
                return false;
            }

            @Override
            public boolean onMessageLongClick(Context context, View view, Message message) {
                return false;
            }
        });

        // 消息接收监听
        RongIM.setOnReceiveMessageListener(new RongIMClient.OnReceiveMessageListener() {
            /**
             * 收到消息的处理。
             *
             * @param message 收到的消息实体。
             * @param i       剩余未拉取消息数目。
             * @return 收到消息是否处理完成，true 表示自己处理铃声和后台通知，false 走融云默认处理方式。
             */
            @Override
            public boolean onReceived(Message message, int i) {
                refreshUser(message.getSenderUserId());
                if (mCurrentFragmentId == R.id.tab_message_layout) {
                    return true;
                }
                mHandler.sendEmptyMessage(MSG_RECEIVE);
                return true;
            }
        });
    }

    /**
     * 刷新用户头像
     * 如果已经存在列表中,直接获取刷新
     * 否则,向后台请求数据再刷新
     */
    private void refreshUser(final String senderUserId) {
        boolean hasUser = false;
        final Uri avatar;
        final String nickname;
        // 遍历列表
        if (mUserList.size() != 0) {
            for (Map.Entry<String, RongIMItem> entry : mUserList.entrySet()) {
                if (entry.getKey().equals(senderUserId)) {
                    hasUser = true;
                    avatar = entry.getValue().getAvatar();
                    nickname = entry.getValue().getNickname();
                    RongIM.setUserInfoProvider(new RongIM.UserInfoProvider() {
                        @Override
                        public UserInfo getUserInfo(String s) {
                            UserInfo userInfo = new UserInfo(senderUserId, nickname, avatar);
                            return userInfo;
                        }
                    }, true);
                    RongIM.getInstance().refreshUserInfoCache(new UserInfo(senderUserId, nickname, avatar));
                    break;
                }
            }
        }

        // 列表中没有,向后台请求
        if (!hasUser) {
            mSenderUid = senderUserId;
            mHandler.sendEmptyMessage(MSG_GET_UER);
        }
    }
}
